

// class Student{
//      fullName : string;
//      constructor(public firstName, public middleInital, public lastName){
//             this.fullName = firstName + " " +  middleInital + " " + lastName;
//      }
// }
//
// function greeter(person: Student) {
//     console.log(person )
//     return "Hello, " + person.fullName;
// }
//
// let user = new Student("刘","读书","子彬");
// document.body.innerHTML = greeter(user);

/********************************************************1.基本数据类型**************************************/

//数据类型有两种：
// 原始数据类型（Primitive data types）  布尔值、数值、字符串、null、undefined Symbol
// 对象类型（Object types）。

//bool
let  isSuccess : boolean = true;

//let  boolObjcet : any = new Boolean(1);  //使用构造函数 Boolean 创造的对象不是布尔值,返回一个Bool对象

//数值
var  pricecount : number = 3.04;
var  notANumber : number = NaN;

//字符串
let  personname : string = '小名';

//多行字符串  模板字符串
let  moreString: string = `Hello, my name is ${personname}
I will be good ${isSuccess}`;  //其中 ` 用来定义 ES6 中的模板字符串，${expr} 用来在模板字符串中嵌入表达式。

//void 表示没有任何类型 ,没有函数返回值
function message(mess : string) : void{}


//undefined和null两者各自有自己的类型分别叫做undefined和
// null undefined 类型的变量只能被赋值为 undefined，null 类型的变量只能被赋值为 null。
// 与 void 的区别是，undefined 和 null 是所有类型的子类型

let  nul : null = null;
let  defin : undefined = undefined;



//any  任意类型 可以调用方法
// 任意值（Any）用来表示允许赋值为任意类型。
// object 任意类型  不能调用方法
//声明一个变量为任意值之后，对它的任何操作，返回的内容的类型都是任意值。
let  notsure : any = 4;
notsure = 'ererrre';
notsure = true;
console.log(notsure);


//数组表现方式 类型[]
let  fabinaqie : number[] = [1,2,3,3,4];

//数组泛型
let dataList :  Array<number> = [1,2,3,4];

//接口表示数组
interface IArray{
    [index: number] : number;
}
let fibonacci:IArray = [1,2,3,3,4,5,5];

//类数组：不是数组类型
function defaultsum(){
    let list : IArguments = arguments;
}


//元祖tuple元组类型允许表示一个已知元素数量和类型的数组，各元素的类型不必相同。 比如，你可以定义一对值分别为 string和number类型的元组。

let tupledata : [string, number] = ['2332', 33];


//枚举
enum orderStatus {
    orderStatus_None = 0,
    orderStatus_Paying = 1,
    orderStatus_Payed = 2,
}
console.log(orderStatus[0]);

//declare 只会用于编译检查，检查完成之后要被删除
// 外部枚举与声明语句一样，常出现在声明文件中
declare enum Directions {
    Up,
    Down,
    Left,
    Right
}


//泛型 T 用来指代任意输入的类型  输入什么类型 返回就是什么类型
function createArray  <T>(length : number, value : T) : Array<T>{
    let result: T[] = [];
    for (let i = 0; i < length; i++){
        result[i] = value;
    };
    return result;
}
createArray<string>(3,"x"); // ['x', 'x', 'x']




//never类型  表示的是那些永不存在的值的类型



//类型推到
//如果定义的时候没有赋值，不管之后有没有赋值，都会被推断成 any 类型而完全不被类型检查：
//let  myFavoriteNumber;  //any类型
let  someValue = 'this is type string';

//类型断言 可以用来手动指定一个值的类型。<类型>值 === 值 as 类型
let  someVauleLength : number = (someValue as string).length;
console.log(someVauleLength);





//联合类型  联合类型使用 | 分隔每个类型

let myUnionType : string | number; //string 或者 number，但是不能是其他类型
myUnionType = "string";
myUnionType = 23;
//myUnionType =flase; error

// 联合类型只能访问此联合类型的所有类型里共有的属性或方法

//声明文件
//声明语句
declare var jQuery : (selecter : string) => any;
jQuery('#foo');

//通常我们会把类型声明放到一个单独的文件中，这就是声明文件



//Object 非原始类型
console.log(Object.create({ prop: 0 })); // OK
console.log(Object.create(null)); // OK


/********************************************************2.变量声明**************************************/
// var

//let 代替 var  变量不能重复定义
let contnt : number = 3;
//let  contnt : number = 5; //ERROR


//const 常量修饰  不能对变量进行更改



//解构和展开

//数组解构
let [first, ...rest] = [1,2,3,4];


//对象解构
let personModel = {
      a : 'aaaaaa',
      b : 'bbb',
      c : 'CCCCCC'
};
let { a , b } = personModel; //o.a and o.b 创建了 a 和 b

//Javascript通常会将以 { 起始的语句解析为一个块。
({a,b} = {a:'大A',b : '小B'});
console.log(a);












